home *** CD-ROM | disk | FTP | other *** search
/ Stone Design / Stone Design.iso / Stone_Friends / Wave / WavesWorld / Source / IBPalettes / WW3DKit / RIBCommandList.m < prev    next >
Encoding:
Text File  |  1995-04-10  |  17.2 KB  |  720 lines
  1. // copyright 1993 Michael B. Johnson; some portions copyright 1994, MIT
  2. // see COPYRIGHT for reuse legalities
  3. //
  4.  
  5. #import "RIBCommandList.h"
  6. #import "RIBCommand.h"
  7.  
  8. #import "WW3DShape.h"
  9. #import "WWSceneClock.h"
  10. #import "WW3DAttributeState.h"
  11. #import "usefulWW3DFunctions.h"
  12.  
  13. @implementation RIBCommandList
  14.  
  15. - init
  16. {
  17.   [super init];
  18.   eveCode = NULL;
  19.   dirtyBoundingBox = TRUE;
  20.  
  21.   return self;
  22.  
  23. }
  24.  
  25. - awake
  26. {
  27.   [super awake];
  28.  
  29.   eveCode = NULL;
  30.   dirtyBoundingBox = TRUE;
  31.  
  32.   return self;
  33. }
  34.  
  35. - free
  36. {
  37.   //NXLogError("RIBCommandList %d being free'ed\n", self);
  38.   //NXLogError("RIBCommandList: freeing %p", self);
  39.   [self freeObjects];  
  40.   if (eveCode)
  41.   {  free(eveCode);
  42.   }
  43.   return [super free];
  44. }
  45.  
  46. // override all list insertion and deletion routines to mark myself dirty
  47. - addObject:anObject { dirtyBoundingBox = TRUE; return [super addObject:anObject]; }
  48. - insertObject:anObject at:(unsigned)index { dirtyBoundingBox = TRUE; return [super insertObject:anObject at:(unsigned)index]; }
  49. - removeObjectAt:(unsigned)index { dirtyBoundingBox = TRUE; return [super removeObjectAt:(unsigned)index]; }
  50. - removeLastObject { dirtyBoundingBox = TRUE; return [super removeLastObject]; }
  51. - replaceObjectAt:(unsigned)index with:newObject { dirtyBoundingBox = TRUE; return [super replaceObjectAt:(unsigned)index with:newObject]; }
  52. - appendList: (List *)otherList { dirtyBoundingBox = TRUE; return [super appendList: (List *)otherList]; }
  53. - addObjectIfAbsent:anObject { dirtyBoundingBox = TRUE; return [super addObjectIfAbsent:anObject]; }
  54. - removeObject:anObject  { dirtyBoundingBox = TRUE; return [super removeObject:anObject]; }
  55. - replaceObject:anObject with:newObject  { dirtyBoundingBox = TRUE; return [super replaceObject:anObject with:newObject]; }
  56. - empty  { dirtyBoundingBox = TRUE; return [super empty]; }
  57.  
  58. - (const char *)eveCode { return eveCode; }
  59. - setEveCode:(char *)newEveCode
  60. {
  61.   if (eveCode)
  62.   {  free(eveCode);
  63.   }
  64.   if (newEveCode)
  65.   {  eveCode = NXCopyStringBuffer(newEveCode);
  66.   } 
  67.   else
  68.   {  eveCode = NULL;
  69.   } 
  70.   return self;
  71. }
  72.  
  73. - _setEveCode:(char *)newEveCode
  74. {
  75.   if (newEveCode)
  76.   {  eveCode = NXCopyStringBuffer(newEveCode);
  77.   } 
  78.   else
  79.   {  eveCode = NULL;
  80.   } 
  81.   return self;
  82. }
  83.  
  84. - setEveCodeArgc:(int)argc argv:(char **)argv
  85. {
  86.   int   i, howMany = 1;
  87.   char  *tmpEveCode, *ptr;
  88.  
  89.  
  90.   for (i = 0; i < argc; i++)
  91.   {  howMany += 3 + strlen(argv[i]);
  92.   }
  93.   ptr = tmpEveCode = (char *)calloc(howMany, 1);
  94.  
  95.   sprintf(ptr, "%s ", argv[0]);
  96.   ptr += strlen(argv[0]) + 1;
  97.  
  98.   for (i = 1; i < argc; i++)
  99.   {  sprintf(ptr, "{%s} ", argv[i]);
  100.      ptr += strlen(argv[i]) + 3;
  101.   }
  102.  
  103.   [self setEveCode:tmpEveCode];
  104.  
  105.   free(tmpEveCode);
  106.  
  107.   return self;
  108. }
  109.  
  110. // okay, usually "copy" doesn't actually do a deep copy.
  111. // but, in the case of this subclass, we're gonna.
  112. - copyFromZone:(NXZone *)zone
  113. {
  114.   id   newCopy = [super copyFromZone:zone];
  115.   int  i, howMany = [self count];
  116.   
  117.  
  118.   [newCopy _setEveCode:eveCode];
  119.   for (i = 0; i < howMany; i++)
  120.   {  [newCopy replaceObjectAt:i with:[[self objectAt:i] copyFromZone:zone]];
  121.   }
  122.   return newCopy;
  123. }
  124.  
  125.  
  126. // need to walk down my RIBCommands, asking each one...
  127. - (BOOL)hasBoundingBox 
  128. {  
  129.   int   howMany, i = 0;
  130.   BOOL  found = NO;
  131.  
  132.  
  133.   howMany = [self count];
  134.   while (!found && (i < howMany))
  135.   {  if ([[self objectAt:i] hasBoundingBox])
  136.      {  found = YES;
  137.      }
  138.      i++;
  139.   }
  140.   return found;
  141. }
  142.  
  143. - (BOOL)isLerpable { return YES; }
  144.  
  145. // need to walk down my RIBCommands, asking each one...
  146. - (BOOL)pushesCTM
  147. {  
  148.   int   howMany, i = 0;
  149.   int   pushes = 0, 
  150.         pops = 0;
  151.  
  152.  
  153.   howMany = [self count];
  154.   for (i = 0; i < howMany; i++)
  155.   {  if ([[self objectAt:i] pushesCTM])
  156.      {  pushes++; 
  157.      }
  158.      if ([[self objectAt:i] popsCTM])
  159.      {  pops++; 
  160.      }
  161.   }
  162.   if (pushes > pops)
  163.   {  return YES;
  164.   }
  165.   return NO;
  166. }
  167.  
  168. - (BOOL)popsCTM
  169. {  
  170.   int   howMany, i = 0;
  171.   int   pushes = 0, 
  172.         pops = 0;
  173.  
  174.  
  175.   howMany = [self count];
  176.   for (i = 0; i < howMany; i++)
  177.   {  if ([[self objectAt:i] pushesCTM])
  178.      {  pushes++; 
  179.      }
  180.      if ([[self objectAt:i] popsCTM])
  181.      {  pops++; 
  182.      }
  183.   }
  184.   if (pops > pushes)
  185.   {  return YES;
  186.   }
  187.   return NO;
  188. }
  189.  
  190. - (BOOL)pushesOrPopsCTM
  191. {  
  192.   int   howMany, i = 0;
  193.   int   pushes = 0, 
  194.         pops = 0;
  195.  
  196.  
  197.   howMany = [self count];
  198.   for (i = 0; i < howMany; i++)
  199.   {  if ([[self objectAt:i] pushesCTM])
  200.      {  pushes++; 
  201.      }
  202.      if ([[self objectAt:i] popsCTM])
  203.      {  pops++; 
  204.      }
  205.   }
  206.   if (pushes != pops)
  207.   {  return YES;
  208.   }
  209.   return NO;
  210. }
  211.  
  212. - (float)lastSampleIsAt { return 0.0; }
  213.  
  214.  
  215. - (unsigned long int)maxSampleBandwidth
  216. {
  217.    unsigned long int  maxSampleBandwidth = 50;  //WAVE FIX ME
  218.    int      i, howMany = [self count];
  219.  
  220.  
  221.   for (i = 0; i < howMany; i++)
  222.   {  maxSampleBandwidth += [(id <WWRenderable>)[self objectAt:i] maxSampleBandwidth];
  223.   }
  224.  
  225.   return maxSampleBandwidth;
  226. }
  227.  
  228.  
  229. // need to walk down my RIBCommands, asking each one...
  230. - (BOOL)isMotionBlurrable 
  231. {  
  232.   int   howMany, i = 0;
  233.   BOOL  found = NO;
  234.  
  235.  
  236.   howMany = [self count];
  237.   while (!found && (i < howMany))
  238.   {  if ([[self objectAt:i] isMotionBlurrable])
  239.      {  found = YES;
  240.      }
  241.      i++;
  242.   }
  243.   return found;
  244. }
  245.  
  246. - (BOOL)isCompoundCommand { return YES; }
  247.  
  248.  
  249. // need to walk down my RIBCommands, asking each one...
  250. // no, unfortunately, it's not as easy as that.  
  251. // This is actually much more like a WW3DShape.  
  252. // we might have transformative commands inside the list.
  253. // what if we had a RIBScale and a RIBSphere object?
  254. // we need to keep a notion of a CTM inside the list, and
  255. // apply it to both the bounding box thus far and the current
  256. // command
  257. // NOTE: the changes haven't been made yet...
  258.  
  259. - (int)findBoundingBoxFromRIBCommands:(int)startingIndex using:attributeState startingAt:(RtFloat)shutterOpenTime endingAt:(RtFloat)shutterCloseTime
  260. {
  261.   RtBound   tmpBoundingBox;
  262.   RtMatrix  tmpCTM;
  263.   int       i = startingIndex,
  264.             incr,
  265.             howMany = [self count];
  266.   id        cmd;
  267.   id        newAttributeState;
  268.  
  269.  
  270.   // first we need to find a bounding box to start with
  271.   while (i < howMany)
  272.   {  cmd = [self objectAt:i];
  273.  
  274.      // if the cmd pops the attribute stack, we're done.
  275.      // we return how many commands we've gone through in our time here
  276.      if ([cmd popsCTM])
  277.      {  i++;
  278.         return (i - startingIndex);
  279.      }
  280.  
  281.      if ([cmd pushesCTM])  // here we go again...
  282.      {  newAttributeState = [[WW3DAttributeState alloc] init];
  283.         i++;
  284.         incr = [self findBoundingBoxFromRIBCommands:i using:newAttributeState startingAt:shutterOpenTime endingAt:shutterCloseTime];
  285.         // we now need to merge this sub-attribute block into our current one
  286.         if ([newAttributeState hasBoundingBox])
  287.         {  // This means that the bounding box in newAttributeState needs to be
  288.            // transformed by the ctm of attributeState, and then  we need to 
  289.            // "grow" to the current bound with that tranformed sub-bound.
  290.  
  291.            [attributeState getTransformMatrix:tmpCTM];
  292.           WW3DDetermineBoundGivenBoundAndCTM(&tmpBoundingBox, [newAttributeState boundingBox], tmpCTM);
  293.           [attributeState growBoundingBox:&tmpBoundingBox];
  294.        }
  295.        else
  296.        {  NXLogError("warning: RIBCommandList <%s> has a moot set of commands at indices %d to %d\n", [myShape shapeName], (i - 1), (i + incr - 1));
  297.           NXLogError("\tif there was a LightSource or AreaLight source in there, you can ignore this warning, though...\n");
  298.        }
  299.        i += incr;
  300.      }
  301.      else 
  302.      {  [cmd transformCTM:attributeState startingAt:shutterOpenTime endingAt:shutterCloseTime];
  303.         i++;
  304.      }
  305.  
  306.     if ([cmd hasBoundingBox])
  307.     {  // great! we grow the bound of the current attribute state
  308.        [attributeState growBoundingBox:[cmd boundingBoxStartingAt:shutterOpenTime endingAt:shutterCloseTime]];
  309.     }
  310.  
  311.   }
  312.   return (i - startingIndex);
  313. }
  314.  
  315.  
  316.  
  317. - calculateBoundingBoxStartingAt:(RtFloat)shutterOpenTime endingAt:(RtFloat)shutterCloseTime  
  318. {  
  319.   int  i;
  320.   id   newAttributeState;
  321.  
  322.  
  323.   if (![self hasBoundingBox])
  324.   {  return self;  // I don't have a bounding box!
  325.   }
  326.  
  327.   // I have a bounding box; but I'm not sure what to set it to
  328.   // initially...  I'll use the bounding box of the first 
  329.   // RIBCommand I have that has a bounding box.
  330.   newAttributeState = [[WW3DAttributeState alloc] init];
  331.   i = [self findBoundingBoxFromRIBCommands:0 using:newAttributeState startingAt:shutterOpenTime endingAt:shutterCloseTime];
  332.   if (i != [self count])
  333.   {  NXLogError("warning: RIBCommandList in shape <%s> has an unbalanced attribute delimiter at command %d (expected %d)\n", 
  334.                 [myShape shapeName], i, [self count]);
  335.      return nil;
  336.   }
  337.  
  338.   if ([newAttributeState hasBoundingBox])
  339.   {  N3D_CopyBound(*([newAttributeState boundingBox]), boundingBox);
  340.   }
  341.   else
  342.   {  NXLogError("warning: RIBCommandList in shape <%s> thought it had a bounding box, but it seems it doesn't...\n",
  343.                 [myShape shapeName]);
  344.      return nil;
  345.   }
  346.   return self;
  347. }
  348.  
  349.  
  350. - setBoundingBox:(RtBound *)newBoundingBox
  351. {
  352.   N3D_CopyBound(*newBoundingBox, boundingBox);
  353.  
  354.   return self;
  355. }
  356.  
  357. - (RtBound *)boundingBoxStartingAt:(RtFloat)intervalStartTime endingAt:(RtFloat)intervalEndTime
  358. { 
  359.    if (dirtyBoundingBox) 
  360.    {  [self calculateBoundingBoxStartingAt:intervalStartTime endingAt:intervalEndTime];
  361.    }
  362.    return &boundingBox; 
  363. }
  364.  
  365. - setMyShape:shape
  366. {
  367.   int   howMany = [self count], 
  368.         i = 0;
  369.  
  370.  
  371.   myShape = shape;  
  372.   for (i = 0; i < howMany; i++)
  373.   {  [(id <WWRenderable>)[self objectAt:i] setMyShape:myShape];
  374.   }
  375.   return self; 
  376. }
  377.  
  378. - shape { return myShape; }
  379.  
  380. - (unsigned long int)dataBandwidth
  381. {
  382.    int   howMany = [self count], 
  383.          i = 0;
  384.    unsigned 
  385.        long int dataBandwidth = 0;
  386.  
  387.  
  388.   for (i = 0; i < howMany; i++)
  389.   {  dataBandwidth += [(id <WWRenderable>)[self objectAt:i] dataBandwidth];
  390.   }
  391.   
  392.   return dataBandwidth;
  393. }
  394.  
  395.  
  396. // note: because we've made the WWSampleList "safe" for having
  397. // multiple samples with the same data, it's perfectly valid to return
  398. // yourself or b
  399. - lerpWith:b by:(float)uValue
  400. {
  401.    id  newMe = nil, newElement;
  402.    int i, howMany = [self count];
  403.  
  404.  
  405.    if (([self class] != [b class]) || (uValue <= 0.0) || (howMany != [b count]))
  406.    {  return self;
  407.    }
  408.  
  409.    if (uValue >= 1.0)
  410.    {  return b;
  411.    }
  412.  
  413.    newMe = [self copyFromZone:[self zone]];
  414.    [newMe empty];
  415.  
  416.    for (i = 0; i < howMany; i++)
  417.    {  newElement = [[self objectAt:i] copyFromZone:[self zone]];
  418.       if ([newElement isLerpable])
  419.       {  [newElement lerpSelfWith:[b objectAt:i] by:uValue];
  420.       }
  421.       [newMe insertObject:newElement at:i];
  422.    }
  423.  
  424.    return newMe;
  425. }
  426.  
  427. - lerpSelfWith:b by:(float)uValue
  428. {
  429.    id  element;
  430.    int i, howMany = [self count];
  431.  
  432.  
  433.    if (([self class] != [b class]) || (uValue <= 0.0) || (howMany != [b count]))
  434.    {  return self;
  435.    }
  436.  
  437.    if (uValue >= 1.0)
  438.    {  return b;
  439.    }
  440.  
  441.    for (i = 0; i < howMany; i++)
  442.    {  element = [self objectAt:i];
  443.       [element lerpSelfWith:[b objectAt:i] by:uValue];
  444.    }
  445.  
  446.    return self;
  447. }
  448.  
  449.  
  450. - renderMaps:(WW3DCamera *)camera startingAt:(RtFloat)shutterOpenTime endingAt:(RtFloat)shutterCloseTime usingStream:(NXStream *)ns
  451. {
  452.   int   howMany = [self count], 
  453.         i = 0;
  454.  
  455.  
  456.   for (i = 0; i < howMany; i++)
  457.   {  [(id <WWRenderable>)[self objectAt:i] renderMaps:camera startingAt:shutterOpenTime endingAt:shutterCloseTime usingStream:ns];
  458.   }
  459.   
  460.   return self;
  461. }
  462.  
  463. - renderMaps:(WW3DCamera *)camera usingStream:(NXStream *)ns
  464. {
  465.   RtFloat  shutterOpenTime = [camera shutterOpenTime],
  466.            shutterCloseTime = [camera shutterCloseTime];
  467.  
  468.  
  469.   return [self renderMaps:camera startingAt:shutterOpenTime endingAt:shutterCloseTime usingStream:ns];
  470. }
  471.  
  472. - renderMaps:(WW3DCamera *)camera startingAt:(RtFloat)shutterOpenTime endingAt:(RtFloat)shutterCloseTime
  473. {
  474.   int   howMany = [self count], 
  475.         i = 0;
  476.  
  477.  
  478.   for (i = 0; i < howMany; i++)
  479.   {  [(id <WWRenderable>)[self objectAt:i] renderMaps:camera startingAt:shutterOpenTime endingAt:shutterCloseTime];
  480.   }
  481.   
  482.   return self;
  483. }
  484.  
  485. - renderMaps:(WW3DCamera *)camera
  486. {
  487.   RtFloat  shutterOpenTime = [camera shutterOpenTime],
  488.            shutterCloseTime = [camera shutterCloseTime];
  489.  
  490.  
  491.   return [self renderMaps:camera startingAt:shutterOpenTime endingAt:shutterCloseTime];
  492. }
  493.  
  494. - renderSelfAsBox:(WW3DCamera *)camera startingAt:(RtFloat)shutterOpenTime endingAt:(RtFloat)shutterCloseTime
  495. {
  496.   int   howMany = [self count], 
  497.         i = 0;
  498.  
  499.  
  500.   for (i = 0; i < howMany; i++)
  501.   {  [(id <WWRenderable>)[self objectAt:i] renderSelfAsBox:camera startingAt:shutterOpenTime endingAt:shutterCloseTime];
  502.   }
  503.   
  504.   return self;
  505. }
  506.  
  507. - renderSelf:(WW3DCamera *)camera startingAt:(RtFloat)shutterOpenTime endingAt:(RtFloat)shutterCloseTime
  508. {
  509.   int                howMany = [self count], 
  510.                      i = 0;
  511.   id <WWRenderable>  obj;
  512.  
  513.  
  514.   if (NXDrawingStatus == NX_DRAWING) 
  515.   {  for (i = 0; i < howMany; i++)
  516.      {  [(id <WWRenderable>)[self objectAt:i] renderSelf:camera startingAt:shutterOpenTime endingAt:shutterCloseTime];
  517.      }
  518.   }
  519.   else
  520.   {  for (i = 0; i < howMany; i++) // do the moot check
  521.      {  obj = (id <WWRenderable>)[self objectAt:i];
  522.         if (![obj isMoot])
  523.         {  [obj renderSelf:camera startingAt:shutterOpenTime endingAt:shutterCloseTime];
  524.         }
  525.      }
  526.   }
  527.  
  528.   return self;
  529. }
  530.  
  531. - renderSelf:(WW3DCamera *)camera
  532. {
  533.   RtFloat  shutterOpenTime = [camera shutterOpenTime],
  534.            shutterCloseTime = [camera shutterCloseTime];
  535.  
  536.  
  537.   return [self renderSelf:camera startingAt:shutterOpenTime endingAt:shutterCloseTime];
  538. }
  539.  
  540. - preRenderSelf:(WW3DCamera *)camera startingAt:(RtFloat)shutterOpenTime endingAt:(RtFloat)shutterCloseTime
  541. {
  542.   return [self preRenderSelf:camera startingAt:shutterOpenTime endingAt:shutterCloseTime];
  543. }
  544.  
  545. - preRenderSelf:(WW3DCamera *)camera 
  546. {
  547.   return [self renderSelf:camera];
  548. }
  549.  
  550.  
  551. - (int)spinThroughSubAttributeBlocks:(int)startingIndex
  552. {
  553.   int       i = startingIndex,
  554.             howMany = [self count];
  555.   id        cmd;
  556.  
  557.  
  558.   while (i < howMany)
  559.   {  cmd = [self objectAt:i];
  560.  
  561.      // if the cmd pops the attribute stack, we're done.
  562.      // we return how many commands we've gone through in our time here
  563.      if ([cmd popsCTM])
  564.      {  i++;
  565.         return (i - startingIndex);
  566.      }
  567.  
  568.      if ([cmd pushesCTM])  // here we go again...
  569.      {  i++;
  570.         i += [self spinThroughSubAttributeBlocks:i];
  571.      }
  572.      else 
  573.      {  i++;
  574.      }
  575.   }
  576.   return (i - startingIndex);
  577. }
  578.  
  579. - transformCTM:(WW3DAttributeState *)attributeState startingAt:(RtFloat)shutterOpenTime endingAt:(RtFloat)shutterCloseTime
  580. { 
  581.   int   howMany = [self count], 
  582.         i = 0;
  583.   id    cmd;
  584.  
  585.  
  586.   while (i < howMany)
  587.   {  cmd = [self objectAt:i];
  588.      if ([cmd pushesCTM])
  589.      {  //okay, recursively spin until we pop or finish...
  590.         i++;
  591.         i += [self spinThroughSubAttributeBlocks:0];
  592.      }
  593.      else
  594.      {  [(id <WWRenderable>)[self objectAt:i++] transformCTM:attributeState startingAt:shutterOpenTime endingAt:shutterCloseTime]; 
  595.      }
  596.   }
  597.   
  598.   return self;
  599.  
  600. }
  601.  
  602. // WavesWorld archiving:
  603. // writeEve:(NXStream *)stream
  604. // writeScene:(NXStream *)stream
  605.  
  606. - oldWriteEve:(NXStream *)stream atTabLevel:(int)tab
  607. {
  608.    int   howMany = [self count], 
  609.          i;
  610.  
  611.  
  612.    for (i = 0; i < howMany; i++)
  613.    {  [(id <WWRenderable>)[self objectAt:i] writeEve:stream atTabLevel:tab];
  614.    }
  615.    return self;
  616. }
  617.  
  618. - writeEve:(NXStream *)stream atTabLevel:(int)tab
  619. {
  620.    int  i;
  621.  
  622.    for (i = 0; i < tab; i++)
  623.    {  NXPrintf(stream, "\t");
  624.    }
  625.    if (!eveCode)
  626.    {  NXPrintf(stream, "# this RIBCommandList had no eveCode...");
  627.    }
  628.    else
  629.    {  NXPrintf(stream, "%s", eveCode);
  630.    }
  631.  
  632.    return self;
  633. }
  634.  
  635. - writeScene:(NXStream *)stream atTabLevel:(int)tab
  636. {
  637.    return [self writeEve:stream atTabLevel:tab];
  638. }
  639.  
  640. - write3DTextScene:(NXStream *)stream atTabLevel:(int)tab index:(int)index time:(float)time until:(float)lastTime
  641. {
  642.    int   howMany = [self count], 
  643.          i;
  644.  
  645.  
  646.    for (i = 0; i < howMany; i++)
  647.    {  [(id <WWRenderable>)[self objectAt:i] write3DTextScene:stream atTabLevel:tab index:index++ time:time until:lastTime];
  648.       // really need to be moving the X coordinate by the X bound of each, and make it cumulative...
  649.    }
  650.    return self;
  651. }
  652.  
  653. - writeInventorAtTime:(float)currentTime to:(NXStream *)stream atTabLevel:(int)tab
  654. {
  655.    int                howMany = [self count], 
  656.                       i, newTab = tab + 1;
  657.    id <WWRenderable>  aCmd;
  658.  
  659.  
  660.    for (i = 0; i < tab; i++)
  661.    {  NXPrintf(stream, "\t");
  662.    }
  663.    NXPrintf(stream, "# RIBCommandList:\n");
  664.    for (i = 0; i < (howMany-1); i++)
  665.    {  aCmd = [self objectAt:i];
  666.       if (![aCmd isMootStartingAt:currentTime endingAt:currentTime])
  667.       {  if ([aCmd popsCTM])
  668.          {  newTab--;
  669.          }
  670.          [aCmd writeInventorAtTime:currentTime to:stream atTabLevel:newTab];
  671.          if ([aCmd pushesCTM])
  672.          {  newTab++;
  673.          }
  674.          NXPrintf(stream, "\n");
  675.       }
  676.    }
  677.  
  678.    aCmd = [self objectAt:i];
  679.    if (![aCmd isMootStartingAt:currentTime endingAt:currentTime])
  680.    {  [(id <WWRenderable>)[self objectAt:i] writeInventorAtTime:currentTime to:stream atTabLevel:newTab];
  681.    }
  682.    return self;
  683. }
  684.  
  685. - (BOOL)theSameAs:otherRIBCommand
  686. {
  687.   // make the default NO...  
  688.   return NO;
  689. }
  690.  
  691. - (BOOL)similarTo:otherRIBCommand 
  692. {
  693.   if ([self class] != [otherRIBCommand class])
  694.   {  return NO;
  695.   }
  696.   return YES;
  697. }
  698.  
  699.  
  700. - (BOOL)isMoot
  701. {
  702.    int  i, howMany = [self count];
  703.  
  704.  
  705.    for (i = 0; i < howMany; i++)
  706.    {  if (![(id <WWRenderable>)[self objectAt:i] isMoot])
  707.       {  return NO;
  708.       }
  709.    }
  710.    // if there are no commands, or they're all moot, then so am i...
  711.    return YES;
  712. }
  713.  
  714. - (BOOL)isMootStartingAt:(float)startTime endingAt:(float)endTime  {  return [self isMoot];  }
  715.  
  716. // boy, this is dumb... This is to get around the stupid warnings from the compiler - ask wave for details
  717. - class { return [super class]; }
  718.  
  719. @end
  720.